package com.briup.day17;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.*;

public class Homework {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 20; i++) {
            list1.add(random.nextInt(30));
        }
        System.out.println(list1);
        ArrayList<Integer> list2 = new ArrayList<>();
        // 遍历集合
        for (int i = 0; i < list1.size(); i++) {
            Integer obj = list1.get(i);
            if (obj % 2 == 0) {
                // 在list2集合中添加被移除的元素
                // 移除元素后，下标也需要跟着变动，
                // 因为某一个元素被移除后，其后续的元素会往前移
                list2.add(list1.remove(i--));
            }
        }
        System.out.println(list1);
        System.out.println(list2);
    }

    private static void test3() {
        // 创建一个方法，实现输出两个直接之间的并集
        List<? extends Serializable> list = List.of("1", 2, 3, 666, LocalDateTime.now());
        List<? extends Serializable> list1 = List.of("2", 1, 3, 777, LocalDateTime.now());
        System.out.println(union(list, list1));
    }

    private static List<?> union(List<?> list, List<?> list2) {
        HashSet<Object> set = new HashSet<>();
        set.addAll(list);
        set.addAll(list2);
        return new ArrayList<>(set);
    }

    private static void test2() {
        List<String> list = new ArrayList<>(List.of("abc", "666", "777"));
        // 遍历集合，判断内部是否存在 字符串 abc，如果存在，将其移除
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            if ("abc".equals(next)) {
                iterator.remove();
            }
        }
        System.out.println(list);

        // 提供了一个方法叫做removeIf()，能够根据你传入的条件删除符合条件的元素
        List<Integer> integers = new ArrayList<>(List.of(1, 33, 222, 666, 777));
        // 删除集合中为奇数的元素
        integers.removeIf((i) -> i % 2 != 0);
        System.out.println(integers);
    }

    private static void test() {
        // 通过静态方法==>of()方法，快速的创建一个不可变的List集合
        List<Integer> list = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));

        // 调用iterator()方法，获取到一个迭代器
        Iterator<Integer> iterator = list.iterator();
        // 使用迭代器对象遍历集合，next()方法可以控制内部的游标向后移动一个下标，
        // 然后返回该下标位置的元素，如果是第一次调用该方法之前，游标为-1；
        // 如果集合内部的所有元素都遍历完，那么此时执行next()方法会报NoSuchElementException异常；
        // 为了避免出现该问题，那么我们在循环迭代时可以同 执行hasNext()方法确定是否还有下一个元素未被遍历
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
            // 在迭代器中可以通过迭代器对象调用其内部的remove方法删除集合中的元素
            if (next == 3) {
                iterator.remove();
            }
        }

        System.out.println("=====================================");

        // 使用foreach进行遍历，快速生成 list.iter
        for (Integer i : list) {
            System.out.println(i);
            // 在foreach中是无法操作集合中的元素，增删改为别的对象都不行，
            // 但是通过对应的引用修改对象内部的属性值是可以的
        }

        System.out.println("=====================");

        // 对于List这一类有序的单列集合来说，是可以通过下标获取集合中的元素，
        // 所以可以使用简单的fori循环进行遍历，
        // 而如Set集合是无序的，所以不能通过简单fori循环进行遍历；
        // 在fori中理论上是可以修改集合内部的元素的
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
            if (i % 3 == 0 && i != 0) {
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);
    }
}
